\section{Sp\'ecification}

Nous avons choisi de diviser notre programme en 3 parties :

\begin{itemize}
	\item Le mod\`ele en Prolog permettant de v\'erifier la validit\'e d'un plateau et de jouer un coup
	\item Le contr\^oleur faisant l'interface entre Prolog et la GUI\footnote{GUI : Graphical User Interface}.
	\item La vue faisant l'interface entre l'utilisateur et le jeu.
\end{itemize}

\subsection{Le plateau}

Le plateau a \'et\'e d\'efinit comme une liste de neuf entier pouvant \^etre :

\begin{itemize}
	\item -1 : Pour le taquin (La case vide sur laquelle rien ne peut \^etre pos\'e.)
	\item  0 : Pour d\'efinir une case vide (Sans pion).
	\item  1 : Pour d\'efinir une case contenant un pion du joueur 1.
	\item  2 : Pour d\'efinir une case contenant un pion du joueur 2.
\end{itemize}

\subsection{Un coup}

De la m\^eme mani\`ere que l'on devait mod\'eliser un plateau, pour jouer un coup, il fallait mod\'eliser un coup.

Un coup est d\'efini par une case de d\'epart, une case d'arriv\'ee et un type de coup.

\subsubsection{La case de d\'epart et la case d'arriv\'ee}

Les cases sont d\'efinie par index de 0 \`a 8.
Si la case de d\'epart est la pile des pions du joueur on \'ecrit -1 par convention.

\subsubsection{Le type de coup}

Il y a 3 coups possibles dont le d\'eplacement de case que l'on a choisi de s\'eparer en deux types.

\begin{itemize}
	\item 0 : Pose d'un pion depuis la pile de pion. La case de d\'epart est donc forc\'ement -1.
	\item 1 : D\'eplacement d'un pion de la case de d\'epart \`a la case d'arriv\'ee.
	\item 2 : D\'eplacement d'une case de la case de d\'epart \`a la case d'arriv\'ee qui doit \^etre le taquin.
	\item 3 : D\'eplacement de deux cases de la case de d\'epart \`a la case d'arriv\'ee. C'est le cas notament lorsque le taquin est au bord du plateau on peut le faire passer d'un bord \`a l'autre en poussant les deux cases.
\end{itemize}

Avec ces sp\'ecifications, on pouvait jouer un coup sur un plateau.

\image{jouer}{D\'efinition Prolog de la mani\`ere de jouer sur le Plateau, \texttt{P}, du Joueur, \texttt{J}, un coup et retourne le nouveau plateau R}{0.8}

\subsection{Le joueur IA}

Pour r\'ealiser le joueur IA, il fallait \^etre capable de r\'ecup\'erer la liste de tous les coups possibles, puis de les \'evaluer pour retourner le meilleur coup \`a jouer.

Nous avons d\'ecid\'e de d\'efinir le meilleur coup comme celui qui laissait le plus de possibilit\'e ensuite c'est la fonction d'\'evaluation par d\'efaut.
Ensuite un coup qui permet de gagner est plus int\'eressant et un coup qui fait perdre est a refuser \`a tout les coups.

Il nous fallait donc un pr\'edicat pour r\'ecup\'erer tous les coups possibles.
Un autre pour \'evaluer le coup.
Un troisi\`eme pour r\'ecup\`erer, pour le plateau et le joueur donn\'e, le coup \`a jouer.

\image{ia}{Code permettant au joueur IA de prendre la d\'ecision du coup \`a jouer sur un niveau.}{0.8}

Une fois le programme capable de d\'etecter le meilleur coup sur un niveau, nous avons d\'ecid\'e d'impl\'ementer 
un arbre MiniMax algorithme qui part du principe que le joueur va jouer le meilleur coup pour lui et permet
de pr\'evoir le coup du joueur adverse et donc de regarder en profondeur quel coup est int\'eressant pour nous.

Comme ce syst\`eme est relativement lourd, on peut couper les branches avec le syst\`eme de l'alpha b\'eta.

C'est donc ce que l'on a mis en place dans un second temps.

\image{Min_Max}{Un arbre Mini-Max}{0.7}
\image{Alpha-beta}{Coupures Alpha et Coupure B\'eta}{0.7}

\subsection{L'interface homme-machine en C++}
	\subsubsection{l'interface graphique :}
	
		Linterface graphique se divise en deux parties:
		\begin{itemize}
		\item Le menu
		\item Le jeu
		\image{screenF3}{L'interface de force3}{0.7}
		\end{itemize}	
		\begin{enumerate}
		\item{Le jeu}

			Le jeu repr\'esente les cases composant le plateau. 

			Pour les mod\'eliser, nous avons utilis\'e les objets QpushButton, qui sont en faites de simples boutons sur lesquels nous affichons l'\'etat de la case.

			La communication entre le joueur et l'application est effectu\'ee gr\^ace \`a des signaux et slots, fonctionnalit\'es de la librairie Qt.  

			Les signaux et slots, vont nous permettre de communiquer entre les classes sans utiliser de pointeurs, ou autres moyens plus compliqu\'e.
			
			Ainsi, par exemple, l'objet plateau sera a l'\'ecoute de chaque case (ou boutons), et chaque clic sera pris en compte.

			Nous g\`erons les \'evenements sur les boutons gr\^ace \`a la m\'ethode MousePressEvent() h\'erit\'e de la classe Qwidget (classe repr\'esentant les objets graphiques).
			\image{mouseEvt}{Code de la fonction de r\'ecuperation des \'ev\'enements souris}{0.6}
			Tous les coups possibles sont valid\'es par un clic droit, ainsi, nous envoyons uniquement un signal au plateau lorsque le joueur clic-droit.
			Le clics gauche sont comptabilis\'es par une modification d'un attribut des objets cellule .

			Un fois le signal envoy\'e, nous calculons le coup, et remettons le plateau \`a jour si le coup est valide.

			Chaque joueur jouant tour \`a tour, nous d\'eterminons, le joueur en cours gr\^ace \`a ce m\^eme syst\`eme de signaux.

			Ainsi, nous alternons entre les diff\'erents joueurs.
		\item{Le menu}

			\image{menu}{Le menu}{0.7}
			Le menu \`a \'et\'e dessin\'e gr\^ace au logiciel QtDesigner, logiciel de la suite Qt permettant de dessiner une interface que l'on va ensuite integrer dans le projet.
Ainsi, nous avons dessiner le menu, puis nous l'avons integr\'e au projet au moyen de la ligne suivante:
			\image{includeUI}{Inclusion du menu dans le code}{0.7}
Cette ligne va permettre d'acceder aux diff\'erentes composantes des menus. On pourra les utiliser dans notre classe comme des attributs existants et définis.
		\end{enumerate}

	\subsubsection{L'interface c++/prolog}
		 Afin que l'application C++ puisse utiliser SWI-Prolog et ainsi int\'eroger le script, nous avons con\c{c}us une classe permettant de r\'ealiser ces operations  tout en permettant à l'utilisateur de le faire en utilisant les types Qt. Pour cela nous avons utilis\'e la librairie fournie avec prolog : \texttt{pl2cpp}.
	Cette classe, nomm\'ee PlInterface,  ne contient qu'une seule m\'ethode : plExecute qui va utiliser de fa\c{c}on transparente, pour l'utilisateur de la classe, le moteur prolog. Son prototype est le suivant :
			\image{plExecute}{prototype de la fonction plExecute}{0.6}
			Description du fonctionnement en pseudo langage de la fonction:
			\begin{enumerate}
				\item{Cr\'eation d'un tableau d'arguments compréhensible par Prolog}
				\begin{tt}
				\begin{small}
				\noindent
				\begin{verbatim}
				PlTermv argspl(argc);

				pour chaque argument
				    si l'argument i est instancié
				      on l'ajoute a la liste
				    sinon
				      on ajoute Xi a la liste des arguments
				\end{verbatim}
				\end{small}
				\end{tt}
                
				\item{On créer la requête prolog et on l'exécute}
				\begin{tt}
				\begin{small}
				\noindent
				\begin{verbatim}
				QString query = predicat + "(" + argv + ")";

				//conversion de la requete en type prolog
				argspl = PlTermv(PlCompound((const char*) query.toLatin1()));
				//On demande a prolog d'executer le predicat avec call, car c'est la seul manière 
				//qui fonctionne si celui-ci est deterministe
				PlQuery myQuery( "call", argspl);
				\end{verbatim}
				\end{small}
				\end{tt}

				\item {Recuperation des réponses}
				\begin{tt}
				\begin{small}
				\noindent
				\begin{verbatim}
				result = myQuery.next_solution();//premiere solution s'il y en a
				QVector<QString> tmprep;//Modelisation d'une reponse

				pour chaque solution()
				    tmprep.clear();
				    on convertit le type prolog en une change de caracter
				    tmpres = tmpres.mid(0,tmpres.length()-1);

				    QVector<QString> tabarg;
				    explose la réponse en une liste d'argument tabarg
				    //on ajoute la reponse a la liste des reponse
				    res.append(tabarg);
				    result = myQuery.next_solution();
				    nbLines++;
				    stop=(nbLines==nbLinesMax);
				fpour
				\end{verbatim}
				\end{small}
				\end{tt}
			\end{enumerate}
			Au dessus de cette classe ce situe une autre,
                        PrologEngine, qui va contenir des fonctions
                        spécifique au programme nécessitant prolog
                        pour la réponse. C'est a dire :
                        \texttt{getBestMove()} pour demander a l'IA de
                        determiner quel coup \texttt{jouer()},
                        \texttt{coupValide()}, et jouer pour demander
                        l'actualisation du plateau de jeu a partir
                        d'un coup.
